Общий курс · осенний семестр · занятие 6

В поисках соратников: командная доска, гибкие методы и GitHub

О чём это занятие
О том, как команде из нескольких студентов работать над одним проектом и не терять друг друга: о договорённостях, гибких методах, командной доске, репозитории на GitHub и файле README, с которого начинается знакомство с проектом.
Аннотация
Конспект начинается с того, что ломается в командной работе: невидимая работа, у каждого своё «готово», знания в одной голове, число каналов связи, которое растёт быстрее команды. Второй раздел излагает гибкие методы по первоисточникам – Agile-манифест, руководства по Scrum и Kanban – и отбирает из них то, что подходит учебной команде: недельный спринт, бэклог, оценку работы в очках и скорость команды, ограничение незавершённой работы, определение готовности. Третий раздел посвящён командной доске: какие зоны на ней нужны, как её вести и какую онлайн-доску выбрать. Четвёртый раздел проводит по GitHub: issues и вехи-спринты, доска Projects с оценками, ветки нескольких разработчиков, pull request с ревью и автоматическими тестами, конфликт слияния, релизы. Пятый – пошаговая работа в GitHub Desktop. Шестой – README и Markdown: что должно быть в README, как его читают и как не ошибиться в разметке. Завершает конспект задание – репозиторий и доска команды.
Пререквизиты
Из занятия 5 понадобятся паспорт критерия и правила сравнительной таблицы (разделы 4.5 и 7.5): по ним сравнивают аналоги на командной доске и выбирают саму доску. Из занятия 4 – таблица «что искать проектам разных траекторий» (раздел 3.12): хранилища кода и правила лицензий пригодятся при заполнении README. Устанавливать заранее ничего не нужно: GitHub Desktop ставится на занятии.
Мотивация
Проект по практике делает команда, а оценивают каждого. На защите спрашивают, кто что сделал, как команда договаривалась и где лежит результат. Ответить на это помогают три вещи: доска, на которой видна работа команды, репозиторий, где у каждого изменения есть автор и дата, и README, по которому проверяющий за пять минут понимает, что это за проект и как его запустить. Те же три вещи потом встретятся на любой работе в разработке.

1. Зачем команде договорённости

Программу, которую пишут четверо, целиком не видит никто, пока её не соберут. Каждый видит свою часть, а общую картину – какая цель, что предстоит сделать, кто чем занят, что уже готово – приходится собирать по разговорам. Поэтому команде нужны средства, которые делают эту картину видимой: договорённости о работе, командная доска и общий репозиторий. Им и посвящено занятие.

Сначала о том, что ломается без них.

Есть и причина, которая с ростом команды только усиливается. Ещё в 1975 году руководитель разработки операционной системы IBM OS/360 Фредерик Брукс заметил, что если каждый участник должен согласовывать работу с каждым, число таких связей равно n(n − 1)/2. У троих – три связи, у четверых – шесть, у шестерых – пятнадцать (рис. 1). Работа на одного человека при этом не уменьшается, а время на согласование растёт почти как квадрат численности команды. Брукс сформулировал из этого закон, который носит его имя: добавление людей в опаздывающий программный проект задерживает его ещё больше.

3 участника3 связи 4 участника6 связей 6 участников15 связей
Рис. 1. Число связей между участниками, если каждый согласует работу с каждым: n(n − 1)/2. Команда выросла вдвое – связей стало впятеро больше.

Отсюда понятно, почему договорённости нужны не «для порядка». Команда снижает число согласований двумя способами: делает работу видимой, чтобы о состоянии дел не приходилось спрашивать каждого, и договаривается заранее, чтобы одни и те же вопросы не решать каждый раз заново. Готовые наборы таких договорённостей существуют уже несколько десятилетий; самые известные из них называют гибкими методами.

2. Гибкие методы: Agile, Scrum, Kanban

О гибкой разработке пишут много, и её легко понять неверно – например, решить, что «гибко» значит «без планов и без документов». Поэтому начнём с первоисточников.

2.1. Agile-манифест

В феврале 2001 года семнадцать разработчиков, авторов разных методов, собрались на горнолыжном курорте Сноуберд в штате Юта и записали то общее, что было в их подходах. Получился короткий текст – «Манифест гибкой разработки программного обеспечения». Его основная часть – четыре ценности:

Люди и взаимодействие важнее процессов и инструментов.
Работающий продукт важнее исчерпывающей документации.
Сотрудничество с заказчиком важнее согласования условий контракта.
Готовность к изменениям важнее следования первоначальному плану.

То есть, не отрицая важности того, что справа, мы всё-таки больше ценим то, что слева.

Agile-манифест разработки программного обеспечения, 2001 (официальный перевод на русский язык)

Последняя фраза и есть ответ на главное заблуждение. Манифест не отменяет ни процессов, ни документов, ни планов – он ставит их на второе место после людей, работающего продукта и способности меняться. К ценностям прилагаются двенадцать принципов; для учебной команды важнее всего три из них: выпускать работающий продукт часто – раз в несколько недель или месяцев, и чем чаще, тем лучше; считать работающий продукт главной мерой прогресса; регулярно обсуждать, как работать эффективнее, и менять свою работу.

Сам манифест не говорит, что делать в понедельник утром. Это говорят конкретные методы; ниже – два из них, Scrum и Kanban.

2.2. Scrum

Scrum описан в руководстве его авторов, Кена Швабера и Джеффа Сазерленда; последняя редакция вышла в 2020 году и переведена на русский. Руководство занимает меньше двадцати страниц и определяет немногое: кто участвует, какие события проводятся и какие артефакты получаются (рис. 2).

артефактБэклог продуктавсё, что нужно сделать, по порядку важностицель продукта
событиеПланированиечто берём в спринт и зачемцель спринта
спринт · 1–4 неделиРаботабэклог спринта; каждый день – ежедневный скрам, 15 минутчто сделано, что мешает
артефактИнкрементработающий результатопределение готовности
событиеОбзорпоказываем сделанное заказчикучто менять в бэклоге
событиеРетроспективакак работать лучшеодно изменение на следующий спринт

следующий спринт начинается сразу после ретроспективы предыдущего

Рис. 2. Спринт в Scrum: артефакты, события и обязательства из руководства по Scrum 2020 года.

Смысл этой конструкции – короткая обратная связь. Каждые одну-четыре недели команда получает работающий результат, показывает его и решает, что делать дальше, вместо того чтобы полгода строить по плану, который устарел через месяц. Ретроспектива применяет ту же идею к самой команде: работа над тем, как работать, – тоже часть работы.

2.3. Kanban

Kanban пришёл в разработку из производственной системы «Тойоты», где карточка (по-японски «канбан») сигнализировала, что пора изготовить следующую партию деталей. Руководство по Kanban определяет его как стратегию оптимизации потока ценности через процесс и называет три практики: определять и визуализировать процесс работы, активно управлять элементами работы в этом процессе и улучшать процесс. В отличие от Scrum, в Kanban нет ни спринтов, ни ролей: работа течёт непрерывно, а доска показывает, где она застряла.

Главный инструмент Kanban – ограничение незавершённой работы (work in progress, WIP). На колонку доски ставят предел: например, «в работе» – не больше трёх карточек на команду. Пока колонка заполнена, новую карточку не берут, а помогают закончить начатое (рис. 3). Правило кажется странным – зачем запрещать работать? – но за ним стоит закон Литтла из теории очередей, доказанный Джоном Литтлом в 1961 году. Для устойчивого процесса

среднее время выполнения подзадачи = средний объём незавершённой работы / пропускная способность.

Если у команды одновременно в работе шесть подзадач, а закрывает она три подзадачи в неделю, каждая подзадача в среднем идёт две недели. Если начатых подзадач три, при той же скорости каждая идёт неделю. Команда работает столько же, но каждая подзадача доходит до «готово» вдвое быстрее, и о проблемах становится известно раньше. Руководство по Kanban поэтому предлагает следить за четырьмя показателями потока: объёмом незавершённой работы, пропускной способностью, возрастом подзадачи (сколько она уже в работе) и временем цикла (сколько она шла от начала до конца).

Бэклог
Компас
Таблица рекордов
Второй уровень
К выполнению
Справка по клавишам
В работе 4 / 3
Метка и очки
Факел
Карта игрока
Звук шагов
На ревью 0 / 2
Готово
Окно игры
Тесты в Actions
README
Рис. 3. Доска Kanban с ограничениями незавершённой работы. В колонке «В работе» четыре карточки при пределе в три, а на ревью пусто: начатого много, законченного мало. Новую карточку здесь не берут – сначала помогают довести начатые.

Scrum и Kanban не соперники: можно работать спринтами по Scrum и при этом вести доску по правилам Kanban, с пределами незавершённой работы. Так и стоит работать учебной команде.

2.4. Что взять учебной команде

Учебная команда – не команда в компании: участники видятся раз в неделю, у каждого ещё пять предметов, а заказчиком бывает преподаватель или сотрудник вуза. Поэтому из Scrum и Kanban берут не всё, а то, что окупается при такой нагрузке.

ПрактикаКак в Scrum или KanbanКак в учебной команде
Спринтот недели до месяцанеделя: от занятия до занятия, чтобы обзор совпадал со встречей с преподавателем
Планированиедо 8 часов на месячный спринт15–30 минут в начале недели: цель спринта одной фразой и подзадачи с исполнителями
Ежедневный скрам15 минут каждый деньписьменная сверка 2–3 раза в неделю в одно и то же время: что сделал, что сделаю, что мешает
Обзорпоказ инкремента заказчикупоказ работающей версии на занятии; номер версии – по спринту
Ретроспективадо 3 часов на месячный спринт10–15 минут раз в две недели: что помогло, что мешало, какое одно правило меняем
Бэклогупорядоченный список работыподзадачи – карточками на командной доске или issues в GitHub; порядок и статус – там же
Оценка и скоростьразмер работы оценивают сами разработчики; в Kanban следят за пропускной способностьюоценка в очках у каждой подзадачи спринта; в спринт берут столько, сколько закрывали в последних спринтах
Ограничение WIPпредел на колонкуне больше одной-двух подзадач в работе на человека
Определение готовностиобязательство инкремента5–6 пунктов в файле CONTRIBUTING.md репозитория (раздел 4.4)

Чтобы спринт не превращался в список желаний, подзадачи оценивают. Оценивают не в часах – время на незнакомую работу угадать трудно, – а в условных очках, сравнивая подзадачи между собой: 1 – совсем просто, 2 – понятно, как делать, 3 – придётся разбираться, 5 – много работы. Подзадачу на 8 очков и больше делят на части. Оценку ставят вместе на планировании: каждый называет свою, и если оценки расходятся, тот, кто назвал больше, объясняет, что увидел. Так в обсуждение попадает то, что остальные могли упустить.

Сумма очков подзадач, закрытых за спринт, – скорость команды. Незакрытая подзадача не засчитывается частично: она переходит в следующий спринт целиком. По скорости и планируют: в следующий спринт берут примерно столько очков, сколько команда закрывала в среднем за последние два-три спринта, а не столько, сколько хочется сделать. Если разделить оставшийся объём проекта на скорость, получится, сколько спринтов осталось работать, – и сразу видно, успевает ли команда к защите. Как вести оценки на доске Projects, показано в разделе 4.3.

2.5. Как записать подзадачу

В отчёте по практике задача – отдельный этап работы, например проектирование или тестирование и отладка; задачи из введения потом становятся главами (справка «Структура отчёта и ВКР», раздел 2.3). Для спринтов её делят на подзадачи – элементы бэклога, каждый из которых можно сделать за неделю. На онлайн-доске подзадачу записывают карточкой, на GitHub – issue (раздел 4.2). Хорошая подзадача описывает результат, который можно показать, а не действие; её можно оценить и закончить за один спринт; у неё один исполнитель; и в ней записано, как проверить, что работа сделана: что открыть или запустить и что должно получиться. Последнее важнее, чем кажется: без способа проверки спор о том, готова ли подзадача, решается не фактами, а настроением.

Способ проверки и определение готовности – разные вещи. Способ проверки свой у каждой подзадачи: что именно должно получиться. Определение готовности одно на всю команду: что выполняется для любой подзадачи – ревью другого участника, слияние в основную ветку, обновлённая документация. Подзадачу переносят в «Готово», когда выполнено и то и другое.

Типичная ошибка записывать подзадачу как действие разработчика – «сделать бэкенд», «доделать дизайн». Такую подзадачу нельзя ни оценить, ни проверить, и она никогда не заканчивается. Подзадача должна описывать результат, который можно показать, и укладываться в спринт; если не укладывается – её делят на части, каждая из которых сама по себе что-то даёт пользователю.
Тренажёр · что не так с подзадачей?

Перед вами подзадачи из бэклога команды, которая делает небольшую игру. Для каждой выберите главную проблему или «подзадача в порядке»; после ответа появится объяснение.

Обсудим в аудитории
  1. Какие две-три договорённости из таблицы раздела 2.4 команде стоит принять уже сейчас, пока идёт проектирование, а какие понадобятся, когда начнётся программирование?
  2. Что должно быть выполнено, чтобы подзадачу «Сравнительная таблица аналогов» можно было перенести в «Готово»? Опираясь на занятие 5, запишите три-четыре условия, которые проверит человек не из команды.

Договорённости бесполезны, если их никто не видит. Поэтому следующий шаг – доска, на которой видны и договорённости, и работа команды.

3. Командная доска

3.1. Зачем доска

Доска – общее пространство, где команда держит всё, что должно быть на виду: цель и договорённости, анализ аналогов, диаграммы, эскизы экранов, а если команда так решила, то и подзадачи спринта. Один из авторов Agile-манифеста назвал такие вещи информационными радиаторами: они излучают сведения сами, и чтобы узнать состояние дел, никого не нужно спрашивать. В офисе это были доски с карточками на стене, в распределённой команде – онлайн-доски (раздел 3.4).

Хорошая доска экономит те самые согласования из раздела 1. Новый участник открывает её и за десять минут видит, что уже решено и почему. Преподаватель видит, кто чем занят, не устраивая опроса. А сама команда видит то, чего не видно в переписке: что карточка висит в работе вторую неделю или что в колонке «На ревью» скопились карточки.

3.2. Из каких зон состоит доска

Доска делится на зоны, и у каждой зоны своё назначение. Зоны заводят в первый же день, даже если они пока почти пустые: так сразу видно, чего команда ещё не сделала. Каждая зона – отдельный фрейм, а её название пишут крупным текстом внутри фрейма, чтобы его было видно при любом масштабе. Примерная раскладка – на рис. 4.

Рис. 4. Примерная раскладка командной доски: шесть зон-фреймов в порядке, в котором их читает новый человек. Цвет стикера означает его тип – по легенде в зоне 1.

Так выглядят три зоны учебной доски – её подготовили для занятия, данные на ней условные: цель и договорённости (рис. 5), анализ (рис. 6) и ретроспектива (рис. 7).

Зона «Цель и договорённости»: название зоны крупным текстом внутри фрейма; жёлтые стикеры «Цель игры: найти клад по старой карте», «Роли: владелец продукта и два разработчика», «Спринт – неделя, обзор – на занятии»; голубой «Ссылки: репозиторий, GitHub Projects»; зелёный «Готово = тесты, ревью, слито в main»; белый стикер с легендой цветов
Рис. 5. Зона «Цель и договорённости» учебной доски: цель, роли, ритм работы, ссылки, определение готовности и легенда цветов.
Зона «Анализ · опрос 16.10»: три стикера с аналогами – Map Map (метка на своей карте), GeoGuessr (очки за точность), Etrian Odyssey (своя карта); четыре стикера по модели Кано – обязательные: метка и очки, линейные: число уровней, привлекательные: карта игрока и компас, безразличные: таблица рекордов; зелёный стикер «Решение 19.10» и серый «Кано, 16.10, 12 студентов, данные условные»
Рис. 6. Зона «Анализ» учебной доски: что берут из аналогов, результаты опроса по модели Кано и решение с датой. Данные опроса в учебном примере условные; сравнительной таблицы аналогов по критериям на этой доске нет.
Зона «Ретроспектива спринта 1 · 25.10», три столбца стикеров. «Помогло»: способ проверки в каждой подзадаче – ревью проходит быстрее; тесты в Actions – в main не попадает сломанный код. «Мешало»: туман и метка правили одну функцию – конфликт; README вернули с ревью – не было снимка окна. «Меняем»: подзадачи, которые меняют одну функцию, делаем по очереди; перед ревью самостоятельно перепроверяем README
Рис. 7. Зона «Ретроспектива» учебной доски: что помогло, что мешало и какие правила команда меняет после первого спринта. Каждая проблема из среднего столбца получила своё правило в правом.

3.3. Как вести доску

Доска быстро зарастает: через месяц на ней сотни объектов, и найти нужное может только автор. Несколько правил держат её в порядке.

3.4. Какую доску выбрать

Онлайн-доску выбирают так же, как любое средство проекта, – по сравнительной таблице из занятия 5: сначала задача и пороги, потом критерии со шкалой и единицей, потом значения с источником и датой.

Задача учебной команды: доска на семестр для анализа, диаграмм, эскизов и ретроспектив; работают 3–5 студентов; иногда доску показывают людям не из команды; платить команда не готова. Порог – бесплатный тариф. Ему отвечают, например, четыре российских сервиса: VK Доска, МТС Линк Доски, sBoard (Эсборд) и доски Битрикс24. Список не полный – онлайн-доски есть и в других платформах, например в Контур.Толке, – и свою таблицу команда собирает тем же способом.

Критерий (шкала, единица)VK ДоскаМТС Линк ДоскиsBoardБитрикс24
Досок на бесплатном тарифе (абсолютная, штук)3 на домен3 на пользователя3без ограничения
Кто может работать на доске (абсолютная, человек)до 5 пользователей, одна командаодна команда; число участников на странице тарифов не указаноприглашённые после регистрации, без ограничения числасотрудники портала, без ограничения числа; внешние участники – по публичной ссылке
Как внешний пользователь может открыть доску (наименований: по ссылке / по приглашению)по приглашениюпо ссылке, только просмотрпо приглашению после регистрации; вход без регистрации – на платных тарифахпо публичной ссылке, просмотр или правка; ссылку можно закрыть паролем и ограничить по времени
История версий (отношений, дни)нетне установлено14не установлено

Значения взяты со страниц тарифов и справки сервисов 20 октября 2026 года. «Не установлено» значит, что на странице тарифов и в справке этого нет; такую ячейку проверяют сами, например заведя пробную доску. Перенос досок из Miro умеют VK Доска, МТС Линк и sBoard. У МТС Линк и Битрикс24 доска входит в платформу с видеовстречами, и доску можно открыть прямо на встрече; у МТС Линк на бесплатном тарифе встреча длится до 60 минут и собирает до 30 участников. У sBoard есть MCP-сервер: к доске можно подключить ИИ-агента, и он сам создаёт на ней стикеры, фреймы и связи; у владельца доски – 100 вызовов в сутки.

Победителя в таблице нет, и это правильно: он зависит от задачи. Если в команде больше пяти человек, отпадает VK Доска; если досок нужно больше трёх, остаётся только Битрикс24. Если доску нужно показать человеку не из команды без регистрации, подходят МТС Линк, где по ссылке можно только смотреть, и Битрикс24, где по публичной ссылке можно и смотреть, и править. Если команда хочет, чтобы ИИ-агент сам раскладывал материалы по доске, или ей важна история изменений, – sBoard. Правила раздела 3.3 от выбора не зависят: зоны, легенда, даты и одно место для подзадач нужны на любой доске.

3.5. Где вести подзадачи спринта

Подзадачи спринта можно вести на онлайн-доске – отдельной зоной с колонками «Бэклог», «К выполнению», «В работе», «На ревью», «Готово», – а можно на GitHub, в Issues и Projects (раздел 4). У доски проще порог входа: всё в одном месте, рядом с анализом и диаграммами, и это удобно, пока проект проектируют и кода ещё нет. У GitHub есть то, чего у доски нет: issue связан с кодом. По issue видно, в какой ветке шла работа, прошли ли тесты и кто проверил изменения, а когда pull request слит, карточка сама переезжает в «Готово».

ЧтоГдеПочему
анализ аналогов, опросы, модель Каноонлайн-доскасвободная раскладка, снимки экрана, стикеры, обсуждение
диаграммы, эскизы экранов, ретроспективыонлайн-доскарисовать и двигать удобнее, чем описывать
подзадачи, спринты, статусыонлайн-доска или GitHub Issues и Projects – что-то однона доске – рядом с анализом; на GitHub – связаны с ветками, pull request и тестами
описание проекта, правила работыREADME и CONTRIBUTING в репозиториилежат рядом с кодом, у каждой правки есть автор и дата

Как устроена работа с подзадачами на GitHub, покажем в разделе 4.

4. GitHub: репозиторий команды

Ниже – работа команды на GitHub по шагам: issues и вехи, доска Projects, ветки, pull request с ревью и проверками, конфликт и релиз. Снимки экрана сделаны в учебном репозитории небольшой игры на Python, где работают два разработчика – назовём их A и Z. Репозиторий подготовлен для занятия: история работы в нём разыграна, а кода ровно столько, сколько нужно для примеров.

4.1. Git за пять минут

GitHub – сервис для хранения репозиториев Git. Git – система контроля версий: она хранит историю всех изменений файлов проекта и позволяет нескольким людям менять их одновременно. Для работы достаточно шести понятий.

На рис. 8 – история учебного репозитория в первом спринте. Каждая подзадача сделана в своей ветке, ветки двух разработчиков живут одновременно, и в main изменения попадают только через pull request.

main feature/3-screen ci/2-tests docs/1-readme feature/4-moves feature/6-mark feature/5-fog обновление из main правка по ревью #16 · конфликт с main #12#13#14#15#17 v0.1.0 разработчик Z разработчик A слияние pull request попытка слияния: конфликт
Рис. 8. История учебного репозитория за первый спринт, упрощённо. Цвет – автор ветки. Одновременно открыто по две-три ветки; долгая ветка docs/1-readme по ходу работы подтягивает свежий main и получает правку по ревью. Пять веток влиты в main через pull request #12–#15 и #17, последний слитый коммит помечен версией v0.1.0. Ветка feature/6-mark отходит от main раньше, чем туда попадает feature/5-fog, и после слияния #17 конфликтует с main (раздел 4.5).

4.2. Issues, метки, вехи

Подзадачи на GitHub записывают как issues. У issue есть заголовок, описание в Markdown, исполнители, метки, веха и обсуждение. Описание отвечает на два вопроса – что сделать и как проверить, что сделано (раздел 2.5), – а метка и веха показывают тип подзадачи и спринт, к которому она относится (рис. 9).

Список Issues учебного репозитория с фильтром is:issue, 11 результатов: открытые «Штраф за время» (enhancement, question) и «Компас показывает направление к кладу» без вехи; «Второй уровень «Катакомбы»», «Карта игрока: пройденные клетки остаются на карте» и ошибка «Уровень без клада: игра падает с TypeError» (bug) в спринте 2; «Метка и очки за точность» в спринте 1 со связанным pull request; закрытая «Факел: видно только клетки рядом с игроком»
Рис. 9. Начало списка issues учебного репозитория: у каждой подзадачи метка типа; запланированные подзадачи привязаны к вехам-спринтам, а «Штраф за время» и «Компас» пока лежат в бэклоге без вехи. Значки справа – связанный pull request и исполнитель.
Окно Create new issue: шаблоны «Ошибка», «Новая возможность» и пустая форма Blank issue Форма нового issue по шаблону «Новая возможность»: поле заголовка, обязательные поля «Что сделать» и «Как проверить» с подсказками, справа уже стоит метка enhancement
Рис. 10. Кнопка New issue открывает выбор шаблона (вверху). Шаблон «Новая возможность» – форма с обязательными полями «Что сделать» и «Как проверить», метка ставится сама (внизу).

Обсуждают подзадачу обычно в чате или на встрече, а в issue записывают итог: что решили и почему. Через месяц такая запись объяснит, почему подзадачу отложили или сделали иначе, чем задумывали.

4.3. Доска в GitHub Projects

Доска на GitHub называется Projects. Это таблица, в которую добавляют issues и pull request из одного или нескольких репозиториев, и её можно показать по-разному: доской с колонками, таблицей или временной шкалой. Колонки доски – значения поля «Статус»; учебной команде достаточно пяти: «Бэклог» – всё, что ещё не взято в спринт; «К выполнению» – взято в текущий спринт, но ещё не начато; «В работе»; «На ревью»; «Готово» (рис. 11).

Доска GitHub Projects «Подземелье картографа · доска команды», разрезанная на два ряда: «Бэклог» (компас, штраф за время), «К выполнению» (три подзадачи второго спринта), «В работе» (метка и очки со связанным pull request #16); ниже «На ревью» (pull request #16) и «Готово» (пять подзадач первого спринта со слитыми pull request)
Рис. 11. Доска Projects учебной команды. Пять колонок не помещаются по ширине страницы, поэтому снимок разрезан: вверху «Бэклог», «К выполнению», «В работе», внизу «На ревью» и «Готово». На карточках закрытых подзадач – номера слитых pull request.

Две настройки делают доску Projects удобнее доски на стене. Поле типа «Итерация» описывает спринты: задаёшь длину спринта, и подзадачи распределяются по неделям, а доску можно отфильтровать по текущему спринту. Встроенные автоматизации сами двигают карточки: в новом проекте по умолчанию включены правила, по которым закрытый issue и слитый pull request получают статус «Готово». Карточку не нужно двигать руками – она переезжает, когда работа действительно влита в основную ветку.

Третья настройка – числовое поле «Оценка» для очков из раздела 2.4. Если сгруппировать таблицу по спринтам и включить сумму этого поля, в заголовке каждого спринта видно, сколько подзадач и сколько очков в него взято (рис. 12).

Вид «Спринты» доски Projects: таблица со столбцами Title, Assignees, Status и Оценка, сгруппированная по полю «Спринт». Спринт 1 (19–25 октября, текущий): 7 элементов, сумма оценок 12 – пять подзадач в статусе «Готово», подзадача «Метка и очки за точность» в работе и её pull request #16 на ревью. Спринт 2: три подзадачи в статусе «К выполнению», сумма 6. Без спринта: компас на 3 очка
Рис. 12. Вид «Спринты» той же доски: таблица сгруппирована по полю «Спринт», в заголовке группы – число элементов и сумма оценок: в первом спринте 12 очков, во втором пока 6, в бэклоге без спринта ещё 3.

На планировании этим пользуются так. Допустим, в первый спринт взяли подзадачи на 12 очков, а к концу недели закрыли пять из них на 9 очков; шестая, на 3 очка, ещё не слита. Скорость первого спринта – 9 очков, а незакрытая подзадача переходит во второй спринт целиком. Значит, во второй спринт стоит брать около 9 очков вместе с перенесённой подзадачей, а не снова 12. Подзадачу без оценки в спринт не берут: если её не получается оценить, в ней чего-то не хватает – например, способа проверки, – и её сначала уточняют.

4.4. Pull request: от ветки к main

Pull request – запрос на слияние ветки в основную. Это главное место командной работы на GitHub: в нём видно, что изменилось, прошли ли тесты, что сказали проверяющие. Работа над подзадачей идёт так:

  1. Создать ветку от свежего main. Имя ветки говорит, что в ней: feature/5-fog – новая возможность по issue 5.
  2. Сделать коммиты. Каждый – одно логическое изменение с сообщением, которое отвечает на вопрос «что сделает этот коммит»: «Скрывать клетки дальше двух шагов от игрока».
  3. Отправить ветку на GitHub и открыть pull request. В описании – что сделано, как проверить и какой issue он закрывает: Closes #5.
  4. Дождаться проверок. GitHub Actions может на каждый pull request запускать тесты; результат – зелёная или красная отметка (рис. 13).
  5. Получить ревью: другой участник читает изменения, проверяет их по разделу «Как проверить» и одобряет (Approve). Если есть замечания, он запрашивает правки (Request changes), а автор отвечает новым коммитом в ту же ветку.
  6. Слить pull request и удалить ветку. Issue, указанный после Closes, закроется сам, карточка на доске переедет в «Готово».
Pull request #17 «Факел: видно только клетки рядом с игроком» в состоянии Merged, автор – разработчик A: разделы описания «Что сделано», «Как проверить», «Связанные issues» с Closes #5 и «Перед отправкой на ревью»; справа ревьюер – разработчик Z – с зелёной галочкой, метка enhancement, веха «Спринт 1» и issue #5 в блоке Development Лента pull request #17: разработчик Z одобрил изменения (approved these changes) с комментарием «Проверено: светло только в двух шагах от игрока, старая карта видна целиком. Всё из «Как проверить» выполнено»; ниже разработчик A слил pull request в main, 1 check passed
Рис. 13. Pull request #17. Вверху – описание по шаблону со ссылкой Closes #5; справа ревьюер с отметкой одобрения и issue, который закроется при слиянии. Внизу – одобрение другого участника и слияние; тесты в GitHub Actions прошли (1 check passed).

Ключевые слова, которые закрывают issue при слиянии, – close, closes, closed, fix, fixes, fixed, resolve, resolves, resolved. Работают они только для pull request в основную ветку репозитория: если ветка вливается в другую ветку, issue останется открытым.

Правила работы команды записывают в файл CONTRIBUTING.md в корне репозитория. GitHub показывает ссылку на него, когда кто-то открывает issue или pull request. Туда записывают правила веток, коммитов и pull request и определение готовности, например:

CONTRIBUTING.md · определение готовности
Подзадача готова, когда:
- [ ] выполнено всё, что записано в разделе «Как проверить»;
- [ ] есть тесты на новое поведение, и все тесты проходят;
- [ ] изменения слиты в main через pull request с одобрением;
- [ ] README обновлён, если изменилось поведение программы;
- [ ] карточка на доске перенесена в колонку «Готово».

Правило «в main только через pull request с одобрением» можно закрепить настройкой защиты ветки в настройках репозитория, если тариф это позволяет. Если нет, правило держится на договорённости, и тогда особенно важно, чтобы оно было записано.

4.5. Конфликт слияния

Конфликт возникает, когда две ветки меняют одни и те же строки. Пример на рисунке: две ветки поменяли функцию draw_dungeon, которая рисует игровое поле. Одна прячет в темноте клетки дальше двух шагов от игрока, другая после того, как игрок поставил метку, показывает сундук на месте клада. Первую ветку слили, и теперь pull request второй сообщает, что у ветки есть конфликты, которые нужно разрешить (рис. 14).

Блок слияния pull request #16: Checks awaiting conflict resolution, 1 successful check; This branch has conflicts that must be resolved, файл dungeon/view.py, кнопка Resolve conflicts; кнопка Merge pull request неактивна Редактор конфликтов GitHub для pull request #16: файл dungeon/view.py, функция draw_dungeon, строки 84–90 между маркерами <<<<<<< feature/6-mark, ======= и >>>>>>> main, над ними ссылки Accept current change, Accept incoming change, Accept both changes; кнопка Mark as resolved
Рис. 14. Конфликт в pull request #16: слить ветку нельзя, GitHub предлагает кнопку Resolve conflicts (вверху); редактор конфликтов в браузере показывает обе версии между маркерами (внизу).

Git не может сам решить, какая из двух правок одних и тех же строк верна, и оставляет обе, помечая их маркерами:

dungeon/view.py · конфликт в draw_dungeon
    if (x, y) == player:
        draw_tile(screen, "player", rect)
<<<<<<< feature/6-mark
    elif reveal and (x, y) == level.treasure:
        draw_chest(screen, rect)
=======
    elif not visible(player, (x, y)):
        pygame.draw.rect(screen, DARK, rect)
>>>>>>> main
    else:
        draw_tile(screen, cell, rect)

Между <<<<<<< и ======= – версия одной ветки, между ======= и >>>>>>> – другой. Разрешить конфликт – значит написать код, который учитывает обе правки, удалить маркеры, запустить тесты и сделать коммит с результатом. Здесь нужны обе проверки, но важен их порядок. Если первой поставить проверку темноты, сундук, до которого не достаёт свет факела, так и останется в темноте, и проверка «после метки видно, где клад был на самом деле» не пройдёт. Поэтому первой идёт проверка метки, второй – темноты. Сделать это можно в браузере кнопкой Resolve conflicts, в GitHub Desktop или в VS Code: все три показывают конфликтующие места и предлагают выбрать одну версию, другую или обе. Вариант «обе» ставит правки подряд в порядке веток и о смысле кода не знает, поэтому результат всё равно читают и проверяют тестами.

Типичная ошибка разрешить конфликт, просто удалив чужую версию, – или удалить только маркеры и оставить обе версии кода подряд. В первом случае пропадает работа товарища, во втором программа перестаёт работать. После разрешения конфликта тесты запускают обязательно.

Конфликтов меньше, когда ветки живут недолго: подзадача на день-два, а не на две недели. Чем дольше ветка расходится с main, тем больше в ней строк, которые успел поменять кто-то другой. Помогает и договорённость на планировании: подзадачи, которые меняют одну функцию, делать по очереди.

4.6. Релизы и номера версий

Когда спринт закончен, его результат помечают версией. В Git это тег – метка на коммите, а на GitHub – релиз: тег с описанием изменений и, если нужно, файлами для скачивания. Номера версий удобно писать по правилам семантического версионирования: MAJOR.MINOR.PATCH. Последнюю цифру увеличивают для исправлений, среднюю – для новых возможностей, первую – для изменений, несовместимых с прежними; версии 0.y.z означают, что проект ещё в начальной разработке и всё может меняться.

В описании релиза пишут, что умеет версия и какие у неё известные ограничения; ниже GitHub сам добавляет список вошедших pull request (рис. 15).

Страница релиза «v0.1.0 – подвал в темноте» с отметкой Latest: тег v0.1.0, коммит be91de7, разделы «Что умеет» и «Известные ограничения» со ссылками на issues #6 и #7; ниже составленный GitHub список What's Changed с pull request #12–#15 и #17 и раздел New Contributors
Рис. 15. Релиз v0.1.0 учебного репозитория: тег, коммит, что умеет версия и известные ограничения; ниже GitHub сам перечислил вошедшие pull request.

Выпускать версию стоит в конце каждого спринта, даже если изменений немного. Релиз фиксирует то, что команда показала на обзоре, и к нему можно вернуться, если следующая версия что-то сломает. Описание релиза пишут для пользователя, а не для разработчиков: что нового, что исправлено, что пока не работает. К концу семестра список релизов становится готовой историей проекта: по нему видно, как продукт рос неделю за неделей, и его можно приложить к отчёту как доказательство хода работы.

GitHub – не единственное хранилище кода. В России работают GitVerse, GitFlic и Мос.Хаб; issues, ветки, запросы на слияние и релизы в них устроены похоже, так что всё сказанное переносится почти без изменений.

5. GitHub Desktop: работа без командной строки

С Git работают из командной строки, из среды разработки или из отдельной программы. Для начала удобнее всего GitHub Desktop – бесплатная программа для Windows и macOS, в которой каждое действие – кнопка, а изменения видно до того, как они сохранены. Git входит в её состав, ставить его отдельно не нужно.

5.1. Установка и вход

Программу скачивают с desktop.github.com. После установки она предлагает войти в учётную запись GitHub – это нужно, чтобы отправлять изменения; вход выполняется через браузер, пароль в программу вводить не нужно. Позже учётную запись можно сменить в меню File → Options → Accounts. При первом запуске программа предлагает пройти встроенное обучение на тренировочном репозитории (рис. 16) – это пятнадцать минут, которые стоит потратить.

Главное окно GitHub Desktop: сверху выбор репозитория, ветки и кнопка Fetch origin; слева вкладки Changes и History и поле сообщения коммита; справа шаги обучения Get started
Рис. 16. Главное окно GitHub Desktop со встроенным обучением. Вверху три кнопки, с которыми работают постоянно: репозиторий, ветка и синхронизация с GitHub.

В окне всё время видны три вещи. Сверху – текущий репозиторий, текущая ветка и кнопка синхронизации, которая в зависимости от состояния называется Fetch origin, Pull origin или Push origin. Слева – вкладки Changes (несохранённые изменения) и History (история коммитов). Внизу слева – поле сообщения коммита и кнопка Commit.

5.2. Получить репозиторий

Если репозиторий команды уже создан на GitHub, его клонируют – получают локальную копию: File → Clone repository (Ctrl+Shift+O). Программа показывает все репозитории, к которым у учётной записи есть доступ; остаётся выбрать нужный и папку на диске (рис. 17).

Окно Clone a repository: вкладка GitHub.com, список репозиториев, выбран ZlonikovButWithAnA/Team0_Practical, поле Local path D:\GitHub\Team0_Practical, кнопка Clone
Рис. 17. Клонирование репозитория: выбрать репозиторий из списка и папку на диске.

Если репозитория ещё нет, его создают: File → New repository (рис. 18). В этом окне сразу задают три вещи, которые потом легко забыть: флажок Initialize this repository with a README создаёт README, список Git ignore добавляет файл .gitignore со списком того, что не нужно хранить в репозитории (для Python – кэш и виртуальное окружение), список License – файл лицензии. Новый репозиторий существует только на компьютере; на GitHub его отправляет кнопка Publish repository, и тут же можно выбрать, будет ли он закрытым.

Окно Create a new repository: имя Team0_Practical, описание, путь D:\GitHub, флажок Initialize this repository with a README, списки Git ignore и License
Рис. 18. Создание репозитория: имя, README, .gitignore и лицензия задаются сразу.

5.3. Рабочий цикл

Работа над подзадачей в GitHub Desktop повторяет шаги раздела 4.4, только каждый шаг – кнопка.

  1. Обновиться. Перейти на main и нажать Fetch origin, затем Pull origin, если программа нашла новые коммиты. Новую работу начинают от свежей версии.
  2. Создать ветку. Current branch → New branch (Ctrl+Shift+N), имя по правилу команды: feature/5-fog.
  3. Изменить файлы в редакторе. Открыть проект в VS Code можно из программы: Repository → Open in Visual Studio Code (Ctrl+Shift+A).
  4. Просмотреть изменения на вкладке Changes: слева список файлов, справа построчная разница – удалённое красным, добавленное зелёным. Флажки у файлов определяют, что войдёт в коммит.
  5. Сделать коммит. В поле Summary – короткое сообщение о том, что делает коммит, в Description – подробности, если нужны. Кнопка Commit to <ветка> сохраняет коммит локально. Сообщение вроде «12» или «правки» через неделю ничего не скажет; лучше «Скрывать клетки дальше двух шагов от игрока».
  6. Отправить. Publish branch для новой ветки или Push origin для уже опубликованной.
  7. Открыть pull request. Кнопка Create Pull Request (Ctrl+R) открывает страницу GitHub с заготовкой запроса; дальше – описание по шаблону, проверки и ревью.
  8. После слияния перейти на main, сделать Pull origin и удалить ветку: Branch → Delete.

5.4. Конфликт в GitHub Desktop

Чтобы подтянуть в свою ветку свежий main, в программе есть команда Branch → Update from main. Если кто-то успел изменить те же строки, программа сообщает о конфликте и показывает список файлов с конфликтами. У каждого файла есть кнопка открыть его в редакторе; VS Code подсвечивает конфликтующие места и предлагает принять одну версию, другую или обе. После правки файл сохраняют, программа отмечает конфликт разрешённым, и кнопка Continue merge завершает слияние. Дальше – как в разделе 4.5: запустить тесты и только потом отправлять.

5.5. Кнопки и команды

Каждой кнопке GitHub Desktop соответствует команда Git. Знать их полезно: в инструкциях, на форумах и в ответах нейросетей пишут именно команды.

ДействиеGitHub DesktopКомандная строка
получить репозиторийFile → Clone repositorygit clone <адрес>
создать ветку и перейти на неёCurrent branch → New branchgit switch -c feature/5-fog
посмотреть изменениявкладка Changesgit status, git diff
сделать коммитSummary → Commit to …git add -A; git commit -m "…"
отправить на GitHubPublish branch / Push origingit push -u origin feature/5-fog
узнать о новых коммитахFetch origingit fetch
получить новые коммитыPull origingit pull
влить main в свою веткуBranch → Update from maingit merge main
историявкладка Historygit log --oneline --graph

Тот же цикл можно пройти в VS Code: панель Source Control показывает изменения, поле сообщения и кнопку Commit, а ветки переключаются в строке состояния внизу окна. Выбор инструмента – дело вкуса; важно, чтобы вся команда соблюдала одни правила веток и сообщений.

6. README и Markdown

README – файл, который GitHub показывает на главной странице репозитория. С него начинает знакомство с проектом каждый: новый участник, преподаватель, член комиссии, работодатель, который смотрит профиль выпускника. За первые минуты README должен ответить на их вопросы, иначе дальше никто не пойдёт.

6.1. Что должно быть в README

РазделНа какой вопрос отвечаетПример
название и одна-две фразычто это и для кого«Небольшая компьютерная игра: найти клад по старой карте и поставить метку»
значки состоянияработает ли сейчасзначок тестов GitHub Actions
возможностичто программа умеет и что в работесписок со ссылками на issues
быстрый старткак запустить за пять минуткоманды, которые можно скопировать, и снимок окна игры
требованиячто нужно установитьPython 3.10 или новее, библиотека pygame; pytest для тестов
структура проектагде что лежиттаблица «путь – что там»
как мы работаемкак участвоватьгде подзадачи и спринты, схема работы с ветками, ссылка на CONTRIBUTING.md
командакто делал и кто за что отвечаеттаблица участников с ролями
лицензияможно ли использоватьMIT со ссылкой на файл LICENSE

Так может начинаться README (рис. 19): каждый раздел отвечает на один вопрос, команды можно скопировать, а правила работы вынесены в отдельный файл, чтобы README оставался коротким.

README учебного репозитория на главной странице: вкладки README, Contributing и MIT license, заголовок «Подземелье картографа», описание игры, значок «Тесты passing» и раздел «Возможности» со ссылками на issues #6, #8 и #9
Рис. 19. Начало README учебного репозитория. GitHub показывает его на главной странице под списком файлов: название, что это за программа, значок тестов, возможности со ссылками на issues.

Главное правило – README пишут для того, кто видит проект впервые. Автор знает, что игра запускается командой python -m dungeon levels/01_cellar.txt, а новичок этого не знает и не догадается. Поэтому лучшая проверка README – попросить человека не из команды склонировать репозиторий и запустить проект по README, ни о чём не спрашивая. Каждый его вопрос – недостающая строка.

6.2. README по ходу проекта

README не пишут в последний день. Его заводят в первом спринте отдельной подзадачей и дополняют каждый спринт, и тогда он совпадает с тем, что умеет программа: если pull request меняет поведение программы, в нём же обновляют README – это пункт определения готовности (раздел 4.4).

Больше всего времени новичку экономят быстрый старт и структура проекта (рис. 20). Команды записаны блоками кода, и GitHub добавляет к каждому блоку кнопку копирования. Под командами – снимок окна: читатель сразу видит, что должно открыться, и может сравнить со своим экраном. Таблица структуры отвечает на вопрос «где что лежит» раньше, чем его зададут.

Разделы README учебного репозитория «Быстрый старт» – требование Python 3.10, команды git clone, cd, pip install -r requirements.txt и python -m dungeon levels/01_cellar.txt, снимок окна игры, управление, команды запуска тестов – и «Структура проекта» – таблица «Путь – Что там»
Рис. 20. Быстрый старт и структура проекта в README: команды можно скопировать, снимок под ними показывает, что должно открыться, таблица говорит, где что лежит. Раздел «Как устроен уровень» между ними на снимке пропущен.
Типичная ошибка писать README в последний день и для себя. README, написанный в начале проекта и дополняемый по ходу работы, заодно служит планом: пустой раздел «Возможности» сразу показывает, что команда ещё не договорилась, что делает.

6.3. Markdown: основы

README пишут на Markdown – языке разметки, который придумал Джон Грубер в 2004 году. Идея в том, что исходный текст читается и без обработки: заголовок отмечен решёткой, курсив – звёздочками, список – дефисами. Первоначальное описание языка оставляло много неясностей, и разные программы показывали один и тот же текст по-разному. Сейчас у языка есть строгая спецификация CommonMark (версия 0.31.2, 2024 год), а GitHub использует её расширение – GitHub Flavored Markdown (GFM), в котором добавлены таблицы, списки с флажками, зачёркивание и автоматические ссылки. Как один и тот же текст выглядит до и после обработки, показывает рис. 21.

исходный текст
# Подземелье картографа

Игра: найти **клад** по старой
карте и поставить метку.

## Быстрый старт

1. Склонировать репозиторий.
2. Запустить:

```bash
python -m dungeon levels/01_cellar.txt
```

| Клавиша | Действие |
|---------|----------|
| W A S D | идти     |

- [x] ходьба и факел
- [ ] метка и очки

Подробнее – в [CONTRIBUTING](CONTRIBUTING.md).
как покажет GitHub

Подземелье картографа

Игра: найти клад по старой карте и поставить метку.

Быстрый старт

  1. Склонировать репозиторий.
  2. Запустить:
python -m dungeon levels/01_cellar.txt
КлавишаДействие
W A S Dидти
  • ходьба и факел
  • метка и очки

Подробнее – в CONTRIBUTING.

Рис. 21. Один и тот же текст в исходном виде и после обработки. Перевод строки внутри абзаца не виден: две строки первого абзаца слились в одну.
Что нужноКак написатьЗамечание
заголовки# Раздел
## Подраздел
после решёток – пробел; уровней шесть; один заголовок первого уровня на файл
абзацпустая строка между абзацамиодиночный перевод строки абзац не разрывает
выделение**полужирный**, *курсив*, ~~зачёркнутый~~зачёркивание – расширение GFM
списки- пункт
1. пункт
вложенный список – отступ в 2–4 пробела
ссылка[текст](https://адрес)на файл репозитория – относительный путь: [лицензия](LICENSE)
картинка![что на снимке](docs/screen.png)текст в квадратных скобках – описание для тех, кто картинку не видит
код в строке`python -m dungeon`имена файлов, команды, значения
блок кода```bash … ```после трёх обратных кавычек – язык, тогда код будет подсвечен
таблица| A | B |
|---|---|
строка из дефисов под заголовком обязательна; расширение GFM
список с флажками- [ ] не сделано
- [x] сделано
в issues и pull request флажки можно отмечать мышью
цитата> текстцитаты могут быть вложенными: >>

6.4. Возможности GitHub

Кроме GFM, GitHub понимает в Markdown ещё несколько вещей, которые делают README и issues нагляднее.

README.md · диаграмма mermaid
```mermaid
flowchart LR
    A[Подзадача в Issues] --> B[Ветка feature/номер-кратко]
    B --> C[Коммиты]
    C --> D[Pull request]
    D --> E{Тесты и ревью}
    E -- замечания --> C
    E -- одобрено --> F[Слияние в main]
```

6.5. Где ошибаются в Markdown

Ниже собраны самые частые неожиданности Markdown. Проверять их удобно на GitHub: любой файл .md там открывается в двух режимах – Code (исходный текст) и Preview (результат), и так же стоит проверять свой README перед тем, как считать его готовым.

Тренажёр · как это покажет GitHub?

Вверху – фрагмент Markdown. Выберите, как его покажет GitHub; после ответа появится объяснение.

7. Задание: репозиторий и доска команды

Задание соединяет всё изложенное: команда заводит репозиторий и доску, договаривается о правилах, планирует первый спринт и проводит работу через полный цикл – от подзадачи до слияния. Результат пригодится в отчёте и на защите: по репозиторию и доске видно, кто что сделал и как шла работа.

  1. Репозиторий. Один участник создаёт репозиторий проекта на GitHub и приглашает остальных и преподавателей (Settings → Collaborators): Zlonikov и EvgenieLebedev. Результатадрес репозитория, все участники в списке.
  2. README и правила. Заполнить README по шаблону: что это, быстрый старт (пусть пока это «как открыть проект»), структура, команда с ролями, лицензия. Добавить CONTRIBUTING.md с правилами веток, коммитов, pull request и определением готовности из 5–6 пунктов. РезультатREADME, который человек не из команды понимает без вопросов.
  3. Бэклог. Записать 6–10 подзадач – карточками на онлайн-доске или issues в GitHub: результат, исполнитель, оценка в очках и способ проверки. Пока идёт проектирование, это могут быть диаграммы, сравнение аналогов, эскизы экранов. Результатбэклог, в котором каждую подзадачу можно проверить.
  4. Спринт 1. Выбрать в спринт 3–5 подзадач, у каждой один исполнитель; цель спринта – одной фразой. Если подзадачи на GitHub – веха «Спринт 1» и доска Projects с колонками «Бэклог», «К выполнению», «В работе», «На ревью», «Готово»; если на онлайн-доске – фрейм спринта с теми же колонками и датами. Результатдоска спринта.
  5. Работа через pull request. Каждый участник проводит хотя бы одну работу через репозиторий: ветка – коммиты с понятными сообщениями – pull request по шаблону – ревью другого участника – слияние. Подойдёт и работа без кода: раздел README, файл диаграммы, сравнение аналогов. Если подзадача в Issues, pull request закрывает её словом Closes #N. Результатпо одному слитому pull request на участника.
  6. Доска. На онлайн-доске (VK Доска, МТС Линк Доски, sBoard, Битрикс24 или другой) – зоны из раздела 3.2 с названиями внутри фреймов, легенда, даты; аналоги проекта сравнены по критериям с паспортами из занятия 5. Результатссылка на доску.
  7. Ретроспектива. В конце недели – 10 минут: что помогло, что мешало, какое одно правило меняем. Записать итог на доске или в README. Результаттри строки и одно изменение.

Работа принимается, если:

Через неделю работы репозиторий и доска сами расскажут, как работает команда: кто какие подзадачи закрыл, сколько их было в спринте, сколько висело на ревью. На защите это лучший ответ на вопрос «кто что сделал» – и для этого его не нужно специально готовить.

8. Свод практик

Ниже правила занятия собраны вместе. Каждое уже встречалось в разделах 1–7; на лицевой стороне карточки – само правило, на обороте – как его применять, а в квадратных скобках – номера источников из списка в конце страницы.

Команда

правило 1Работа должна быть видна.перевернуть →
правило 1Подзадачи и их состояние – на доске, а не в переписке. Чем больше команда, тем дороже вопрос «кто что делает»: связей n(n − 1)/2 [1, 8].
правило 2«Готово» записывают один раз для всех.перевернуть →
правило 2Определение готовности – 5–6 условий в CONTRIBUTING.md: проверка по подзадаче, тесты, ревью, слияние, документация [5].
правило 3Знания – не в одной голове.перевернуть →
правило 3Ревью, README и описания pull request делают так, что работу каждого понимают хотя бы двое. Фактор автобуса у 65 % из 133 популярных проектов GitHub не больше двух [2].

Процесс

правило 4Спринт – неделя, цель – одна фраза.перевернуть →
правило 4От занятия до занятия: планирование в начале, показ работающей версии в конце, номер версии по спринту [5, 3].
правило 5Меньше начатого – быстрее готово.перевернуть →
правило 5Не больше одной-двух подзадач в работе на человека. По закону Литтла время выполнения подзадачи пропорционально объёму незавершённой работы [6, 7].
правило 6Подзадача – результат, а не действие.перевернуть →
правило 6Результат, который можно показать, один исполнитель, оценка и способ проверки. Не укладывается в спринт – делить.
правило 7Ретроспектива – одно изменение.перевернуть →
правило 7Раз в одну-две недели: что помогло, что мешало, какое одно правило меняем. Изменение записывают туда же, где правила [4].

Доска

правило 8Зоны, легенда, даты.перевернуть →
правило 8Каждая тема – фрейм с названием; цвет объяснён легендой; решения и опросы подписаны датой.
правило 9Одно место для подзадач.перевернуть →
правило 9Подзадачи спринта – либо на онлайн-доске, либо в Issues и Projects, связанных с кодом; вторую копию не заводят [20].
правило 10Аналоги – по критериям.перевернуть →
правило 10Задача и пороги, критерии со шкалой и единицей, значения с источником и датой – как в сравнительной таблице занятия 5. Признак, одинаковый у всех вариантов, выбрать не помогает.

GitHub

правило 11Одна подзадача – одна короткая ветка.перевернуть →
правило 11Ветка от свежего main, имя с номером issue, жизнь – день-два. Чем дольше ветка, тем больше конфликтов [16].
правило 12В main – только через pull request.перевернуть →
правило 12Описание по шаблону, зелёные проверки, одобрение другого участника; Closes #N закрывает issue при слиянии [23, 24].
правило 13Сообщение коммита – что он делает.перевернуть →
правило 13«Скрывать клетки дальше двух шагов от игрока», а не «12» или «правки». Один коммит – одно логическое изменение.
правило 14После конфликта – тесты.перевернуть →
правило 14Учесть обе правки, удалить маркеры, запустить тесты и только потом отправлять [25].
правило 15Версия на каждый спринт.перевернуть →
правило 15Релиз с номером MAJOR.MINOR.PATCH и списком изменений; список релизов – готовое доказательство хода работы [28, 27].

README

правило 16README – для того, кто видит проект впервые.перевернуть →
правило 16Что это, как запустить, где что лежит, кто делал, лицензия. Проверка – человек не из команды запускает проект по README [32].
правило 17Markdown проверяют в режиме просмотра.перевернуть →
правило 17Пустые строки перед списками и таблицами, пробел после решёток, язык у блока кода, описание у картинки [34, 35].

Контрольные вопросы

Источники

Список оформлен в виде затекстовых ссылок (ГОСТ Р 7.0.5–2008, ГОСТ Р 7.0.108–2022). Дата обращения к сетевым источникам – 19 и 20 октября 2026 года.

Команда и гибкие методы

  1. Brooks F. P. The Mythical Man-Month: Essays on Software Engineering. — Reading (Mass.) : Addison-Wesley, 1975.
  2. Avelino G., Passos L., Hora A., Valente M. T. A Novel Approach for Estimating Truck Factors : preprint // arXiv. — 2016. — arXiv:1604.06766. — URL: https://arxiv.org/abs/1604.06766 (дата обращения: 19.10.2026).
  3. Манифест гибкой разработки программного обеспечения : [сайт]. — 2001. — URL: https://agilemanifesto.org/iso/ru/manifesto.html (дата обращения: 19.10.2026).
  4. Основополагающие принципы Agile-манифеста : [сайт]. — 2001. — URL: https://agilemanifesto.org/iso/ru/principles.html (дата обращения: 19.10.2026).
  5. Швабер К., Сазерленд Дж. Руководство по Scrum. — 2020. — URL: https://scrumguides.org/docs/scrumguide/v2020/2020-Scrum-Guide-Russian.pdf (дата обращения: 19.10.2026).
  6. Coleman J., Vacanti D., Johnson C. [et al.]. The Kanban Guide. — Version 2025.5. — URL: https://kanbanguides.org/the-kanban-guide/2025.5/ (дата обращения: 19.10.2026).
  7. Little J. D. C. A Proof for the Queuing Formula: L = λW // Operations Research. — 1961. — Vol. 9, No. 3. — P. 383–387. — DOI: 10.1287/opre.9.3.383.

Командная доска

  1. Cockburn A. Agile Software Development. — Boston : Addison-Wesley, 2001.
  2. Kano N., Seraku N., Takahashi F., Tsuji S. Attractive Quality and Must-Be Quality // Hinshitsu (Quality). — 1984. — Vol. 14, No. 2. — P. 147–156. — DOI: 10.20684/quality.14.2_147. — На яп. яз.
  3. Тарифы платформы VK WorkSpace // VK WorkSpace : документация. — Обновлено 24.06.2026. — URL: https://workspace.vk.ru/docs/saas/tariffs-bills/tariffs/ (дата обращения: 20.10.2026).
  4. Тарифы // МТС Линк : [сайт]. — URL: https://mts-link.ru/tariffs/ (дата обращения: 20.10.2026).
  5. Тарифы для вашей команды // Эсборд (sBoard) : [сайт]. — URL: https://sboard.online/pricing (дата обращения: 20.10.2026).
  6. Подробное сравнение тарифов // Битрикс24 : [сайт]. — URL: https://www.bitrix24.ru/prices/compare_cloud_plans.php (дата обращения: 20.10.2026).
  7. Битрикс24 Доски: пространство для визуализации идей // Битрикс24 : база знаний. — URL: https://helpdesk.bitrix24.ru/open/23361080/ (дата обращения: 20.10.2026).
  8. Новое в Досках: возможности и условия использования // Контур.Толк : справка. — URL: https://kontur.ru/talk/spravka/84119-vozmozhnosti_i_usloviya_ispolzovaniya (дата обращения: 20.10.2026).

GitHub и Git

  1. Chacon S., Straub B. Pro Git. — 2-е изд. — Apress, 2014. — URL: https://git-scm.com/book/ru/v2 (дата обращения: 19.10.2026).
  2. About issues // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/issues/tracking-your-work-with-issues/learning-about-issues/about-issues (дата обращения: 19.10.2026).
  3. Syntax for issue forms // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms (дата обращения: 19.10.2026).
  4. Configuring issue templates for your repository // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/configuring-issue-templates-for-your-repository (дата обращения: 19.10.2026).
  5. About Projects // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects (дата обращения: 19.10.2026).
  6. About iteration fields // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/issues/planning-and-tracking-with-projects/understanding-fields/about-iteration-fields (дата обращения: 19.10.2026).
  7. Using the built-in automations // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/issues/planning-and-tracking-with-projects/automating-your-project/using-the-built-in-automations (дата обращения: 19.10.2026).
  8. Pull requests // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/pull-requests/reference/pull-requests (дата обращения: 19.10.2026).
  9. Linking a pull request to an issue // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/linking-a-pull-request-to-an-issue (дата обращения: 19.10.2026).
  10. Merge conflicts // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/pull-requests/reference/merge-conflicts (дата обращения: 19.10.2026).
  11. Setting guidelines for repository contributors // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/communities/setting-up-your-project-for-healthy-contributions/setting-guidelines-for-repository-contributors (дата обращения: 19.10.2026).
  12. About releases // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/repositories/releasing-projects-on-github/about-releases (дата обращения: 19.10.2026).
  13. Preston-Werner T. Семантическое версионирование 2.0.0 : [сайт]. — URL: https://semver.org/lang/ru/ (дата обращения: 19.10.2026).
  14. GitVerse : [сайт]. — URL: https://gitverse.ru/; GitFlic : [сайт]. — URL: https://gitflic.ru/; Мос.Хаб : [сайт]. — URL: https://hub.mos.ru/ (дата обращения: 19.10.2026).

GitHub Desktop

  1. Getting started with GitHub Desktop // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/desktop/overview/getting-started-with-github-desktop (дата обращения: 19.10.2026).
  2. Download GitHub Desktop : [сайт]. — URL: https://desktop.github.com/download/ (дата обращения: 19.10.2026).

README и Markdown

  1. About the repository README file // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-readmes (дата обращения: 19.10.2026).
  2. Gruber J. Markdown // Daring Fireball : [сайт]. — 2004. — URL: https://daringfireball.net/projects/markdown/ (дата обращения: 19.10.2026).
  3. CommonMark Spec. — Version 0.31.2. — 2024. — URL: https://spec.commonmark.org/0.31.2/ (дата обращения: 19.10.2026).
  4. GitHub Flavored Markdown Spec. — Version 0.29-gfm. — 2019. — URL: https://github.github.com/gfm/ (дата обращения: 19.10.2026).
  5. Basic writing and formatting syntax // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax (дата обращения: 19.10.2026).
  6. Creating diagrams // GitHub Docs : [сайт]. — URL: https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-diagrams (дата обращения: 19.10.2026).